home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / net / netRoute.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  38.1 KB  |  1,375 lines
  1. /* 
  2.  * netRoute.c --
  3.  *
  4.  *    This is the code that maintains a table of routes to
  5.  *    Sprite hosts.  The routes contain the transport level
  6.  *    headers that need to be pre-pended to messages so that
  7.  *    they get to the desired Sprite Host.
  8.  *      Routes are added via a system call or determined dynamically using
  9.  *      Sprite's version of ARP (Address Resolution Protocol).  ARP is
  10.  *      invoked when a call to Net_Output is made with a SpriteID for
  11.  *      which there is no route.  Its use is hidden within Net_Output
  12.  *      should not affect the caller of Net_Output.
  13.  *
  14.  *    Operations on routes are:
  15.  *        Net_InstallRoute - Set the Sprite ID for an ethernet address
  16.  *        Net_AddrToID - Get the Sprite ID for a network address
  17.  *        Net_IDToRoute - Return the route for a Sprite host.
  18.  *    Furthermore, the Test_Stats system call will return a route
  19.  *    to a user program with the NET_GET_ROUTE command.
  20.  *
  21.  * Copyright 1988 Regents of the University of California
  22.  * Permission to use, copy, modify, and distribute this
  23.  * software and its documentation for any purpose and without
  24.  * fee is hereby granted, provided that the above copyright
  25.  * notice appear in all copies.  The University of California
  26.  * makes no representations about the suitability of this
  27.  * software for any purpose.  It is provided "as is" without
  28.  * express or implied warranty.
  29.  *
  30.  */
  31.  
  32. #ifndef lint
  33. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/net/netRoute.c,v 9.13 92/06/08 22:49:35 jhh Exp $ SPRITE (Berkeley)";
  34. #endif
  35.  
  36. #include <sprite.h>
  37. #include <net.h>
  38. #include <netRoute.h>
  39. #include <netInt.h>
  40. #include <netUltraInt.h>
  41. #include <sys.h>
  42. #include <stdlib.h>
  43. #include <timer.h>
  44. #include <sync.h>
  45. #include <proc.h>
  46. #include <rpc.h>
  47. #include <string.h>
  48. #include <vm.h>
  49. #include <rpcPacket.h>
  50.  
  51. /*
  52.  * Wildcard address for the Ultranet.  This address matches any address.
  53.  */
  54.  
  55. static Net_UltraTLAddress    wildcardAddress = 
  56.                 {7, NET_ULTRA_TSAP_SIZE};
  57. /*
  58.  * The Route table.
  59.  * The table is indexed by Sprite Host IDs.  Access to
  60.  * the table is synchronized with a MASTER_LOCK to prevent
  61.  * changes from interfering with packet handling.
  62.  */
  63. List_Links    netRouteArray[NET_NUM_SPRITE_HOSTS];
  64. NetHostInfo    netHostInfo[NET_NUM_SPRITE_HOSTS];
  65. int         netNumHosts = NET_NUM_SPRITE_HOSTS;
  66. Sync_Semaphore    netRouteMutex = Sync_SemInitStatic("netRouteMutex");
  67. Sync_Semaphore    netFreeRouteMutex = Sync_SemInitStatic("netFreeRouteMutex");
  68.  
  69. /*
  70.  * Macro to swap the fragOffset field.
  71.  */
  72. #define SWAP_FRAG_OFFSET_HOST_TO_NET(ptr) { \
  73.     unsigned short    *shortPtr; \
  74.     shortPtr = ((unsigned short *)&ptr->ident) + 1; \
  75.     *shortPtr = Net_HostToNetShort(*shortPtr); \
  76. } 
  77.  
  78. static    void        FillUserRoute _ARGS_((Net_Route *routePtr,
  79.                     Net_UserRoute *userRoutePtr));
  80. static    void        FillRouteInfoOld _ARGS_((Net_Route *routePtr,
  81.                     Net_RouteInfoOld *infoPtr));
  82.  
  83. /*
  84.  * This variable is only needed for backwards compatibility with netroute.
  85.  * Once the need for the OLD_NET stuff goes away so can this variable.
  86.  */
  87. static Boolean        oldMode;
  88.  
  89. /*
  90.  *----------------------------------------------------------------------
  91.  *
  92.  * Net_RouteInit --
  93.  *
  94.  *      Initialize the broadcast routes.  The rest of the routes are
  95.  *      installed via the netRoute user program.  
  96.  *
  97.  *    This uses malloc, so it should be called after Mem_Init.
  98.  *
  99.  * Results:
  100.  *    None.
  101.  *
  102.  * Side effects:
  103.  *    Initialize the route table and add the broadcast route.
  104.  *
  105.  *----------------------------------------------------------------------
  106.  */
  107. void
  108. Net_RouteInit()
  109. {
  110.     register int i;
  111.     int spriteID;
  112.  
  113.     /*
  114.      * The route table.  An array of routes is kept for directing
  115.      * messages to other machines.  It is indexed by Sprite host ids.
  116.      */
  117.     for (spriteID=0 ; spriteID<netNumHosts ; spriteID++) {
  118.     List_Init(&netRouteArray[spriteID]);
  119.     bzero((char *) &netHostInfo[spriteID], sizeof(NetHostInfo));
  120.     }
  121.     /*
  122.      * Install the broadcast route(s) so we can do our first broadcast rpcs.
  123.      */
  124.     for (i = 0; i < netNumInterfaces;i++) {
  125.     Net_Interface    *interPtr;
  126.     ReturnStatus    status;
  127.  
  128.     interPtr = netInterfaces[i];
  129.     if (interPtr->flags & NET_IFLAGS_BROADCAST) {
  130.         status = Net_InstallRoute(NET_BROADCAST_HOSTID, 
  131.                 interPtr, &interPtr->broadcastAddress, 
  132.                 NET_PROTO_RAW, "broadcast", "unknown", 
  133.                 0, RPC_MAX_SIZE,
  134.                 (ClientData) 0);
  135.         if (status != SUCCESS) {
  136.         printf(
  137.     "Net_RouteInit: unable to install broadcast route for interface %d\n",
  138.             i);
  139.         }
  140.     }
  141.     }
  142.     return;
  143. }
  144.  
  145. /*
  146.  *----------------------------------------------------------------------
  147.  *
  148.  * Net_InstallRouteStub --    
  149.  *
  150.  *    System call stub for Net_InstallRoute. The Net_RouteInfoOld
  151.  *    stuff is for backwards compatibility and can be removed
  152.  *    once netroute is updated to use Net_UserRoute instead of
  153.  *    Net_RouteInfo.
  154.  *
  155.  * Results:
  156.  *    A return status.
  157.  *
  158.  * Side effects:
  159.  *    See Net_InstallRoute
  160.  *
  161.  *----------------------------------------------------------------------
  162.  */
  163. ReturnStatus
  164. Net_InstallRouteStub(size, userRoutePtr)
  165.     int          size;
  166.     Net_UserRoute *userRoutePtr;    /* Route data */
  167. {
  168.     ReturnStatus     status = SUCCESS;
  169.     Net_Interface     *interPtr;
  170.     Net_UserRoute     userRoute;
  171.  
  172.     if (userRoutePtr == USER_NIL) {
  173.     return (SYS_ARG_NOACCESS);
  174.     }
  175.     /*
  176.      * This stuff allows the new version of Net_Address and Net_UserRoute
  177.      * to work with old applications. 
  178.      */
  179.     if (size == sizeof(Net_RouteInfoOld)) {
  180.     Net_RouteInfoOld    routeInfoOld;
  181.     status = Vm_CopyIn(sizeof(Net_RouteInfoOld), (Address)userRoutePtr, 
  182.               (Address)&routeInfoOld);
  183.     if (status != SUCCESS) {
  184.         return(status);
  185.     }
  186. #define _COPY(field) userRoute.field = routeInfoOld.field
  187.     _COPY(version);
  188.     _COPY(spriteID);
  189.     _COPY(protocol);
  190.     _COPY(flags);
  191.     _COPY(refCount);
  192.     _COPY(routeID);
  193.     _COPY(netType);
  194.     _COPY(userData);
  195.  
  196. #undef _COPY
  197. #define _COPY(field) bcopy(routeInfoOld.field, userRoute.field, sizeof(routeInfoOld.field))
  198.     _COPY(desc);
  199.     _COPY(hostname);
  200.     _COPY(machType);
  201.  
  202. #undef _COPY
  203.     userRoute.minPacket = routeInfoOld.minBytes;
  204.     userRoute.maxPacket = routeInfoOld.maxBytes;
  205.     userRoute.minRpc = 0;
  206.     userRoute.maxRpc = RPC_MAX_SIZE;
  207.     switch(userRoute.netType) {
  208.         case NET_NETWORK_ETHER: 
  209.         status = Net_SetAddress(NET_ADDRESS_ETHER, 
  210.             (Address) &routeInfoOld.netAddress[NET_PROTO_RAW].ether,
  211.             &userRoute.netAddress[NET_PROTO_RAW]);
  212.         break;
  213.         case NET_NETWORK_ULTRA: 
  214.         status = Net_SetAddress(NET_ADDRESS_ULTRA, 
  215.             (Address) &routeInfoOld.netAddress[NET_PROTO_RAW].ultra,
  216.             &userRoute.netAddress[NET_PROTO_RAW]);
  217.         break;
  218.         case NET_NETWORK_FDDI: 
  219.         status = Net_SetAddress(NET_ADDRESS_FDDI, 
  220.             (Address) &routeInfoOld.netAddress[NET_PROTO_RAW].fddi,
  221.             &userRoute.netAddress[NET_PROTO_RAW]);
  222.         break;
  223.     }
  224.     if (status != SUCCESS) {
  225.         panic("Net_InstallRouteStub: Net_SetAddress failed\n");
  226.     }
  227.     if (userRoute.protocol == NET_PROTO_INET) {
  228.         status = Net_SetAddress(NET_ADDRESS_INET, 
  229.         (Address) &routeInfoOld.netAddress[NET_PROTO_INET].inet,
  230.         &userRoute.netAddress[NET_PROTO_INET]);
  231.         if (status != SUCCESS) {
  232.         panic("Net_InstallRouteStub: Net_SetAddress failed\n");
  233.         }
  234.     }
  235.     interPtr = Net_GetInterface(routeInfoOld.netType, 
  236.             routeInfoOld.interface);
  237.     if (interPtr == (Net_Interface *) NIL) {
  238.         printf("Net_InstallRouteStub: can't find interface %d\n",
  239.         routeInfoOld.interface);
  240.         return(GEN_INVALID_ARG);
  241.     }
  242.     userRoute.interAddress = interPtr->netAddress[NET_PROTO_RAW];
  243.     oldMode = TRUE;
  244.     } else if (size == sizeof(Net_UserRoute)) {
  245.     status = Vm_CopyIn(sizeof(Net_UserRoute), (Address)userRoutePtr, 
  246.               (Address)&userRoute);
  247.     if (status != SUCCESS) {
  248.         return(status);
  249.     }
  250.     if (userRoute.version != NET_ROUTE_VERSION) {
  251.         return GEN_INVALID_ARG;
  252.     }
  253.     oldMode = FALSE;
  254.     } else {
  255.     return (GEN_INVALID_ARG);
  256.     }
  257.     interPtr = Net_GetInterfaceByAddr(&userRoute.interAddress);
  258.     if (interPtr == (Net_Interface *) NIL) {
  259.     char    buf[20];
  260.     Net_AddrToString(&userRoute.interAddress, buf);
  261.     printf("Net_InstallRouteStub: can't find interface with address %s\n",
  262.         buf);
  263.     return(GEN_INVALID_ARG);
  264.     }
  265.     status = Net_InstallRoute(userRoute.spriteID,
  266.             interPtr, userRoute.netAddress, 
  267.             userRoute.protocol,
  268.             userRoute.hostname, userRoute.machType, 
  269.             userRoute.minRpc, userRoute.maxRpc,
  270.             userRoute.userData);
  271.     return(status);
  272. }
  273.  
  274. /*
  275.  *----------------------------------------------------------------------
  276.  *
  277.  * Net_InstallRoute --
  278.  *
  279.  *    Install a route to a Sprite host at the specified address.
  280.  *    After installing the route the Sprite ID can be used as an
  281.  *    argument to Rpc_Call to direct an RPC request to that Sprite host.
  282.  *
  283.  * Results:
  284.  *    None.
  285.  *
  286.  * Side effects:
  287.  *    Initialize the entry in the route table which is indexed
  288.  *    by the Sprite ID to point to a route for the Sprite Host.
  289.  *
  290.  *----------------------------------------------------------------------
  291.  */
  292.  
  293. ReturnStatus
  294. Net_InstallRoute(spriteID, interPtr, netAddressPtr, protocol, 
  295.     hostname, machType, minRpc, maxRpc, clientData)
  296.     int         spriteID;    /* Sprite Host ID */
  297.     Net_Interface    *interPtr;    /* Interface route is for. */
  298.     Net_Address     *netAddressPtr;    /* Network addresses (indexed by
  299.                      * protocol). */
  300.     int            protocol;    /* Protocol to use with route. */
  301.     char         *hostname;    /* Human recognizable name */
  302.     char         *machType;      /* Machine type to expand $MACHINE */
  303.     int            minRpc;        /* Minimum RPC size for route. */
  304.     int            maxRpc;        /* Maximum RPC size for route. */
  305.     ClientData        clientData;     /* Data for user-level program. */
  306. {
  307.     register Net_Route     *routePtr;
  308.     Net_Route        *oldRoutePtr = (Net_Route *) NIL;
  309.     ReturnStatus status = SUCCESS;
  310.     char    *headerPtr;
  311.  
  312.     if (Mach_AtInterruptLevel()) {
  313.     printf("Can't install route when at interrupt level (%d)\n",
  314.         spriteID);
  315.     return FAILURE;
  316.     }
  317.     if (spriteID < 0) {
  318.     printf("Invalid sprite id %d\n", spriteID);
  319.     return (GEN_INVALID_ARG);
  320.     }
  321.     /*
  322.      * If we are installing a route and we don't know are own spriteID see
  323.      * if we can learn it from the route.
  324.      */
  325.     if (rpc_SpriteID == 0) {
  326.     if (Net_AddrCmp(&interPtr->netAddress[protocol],
  327.         &netAddressPtr[protocol]) == 0) {
  328.         rpc_SpriteID = spriteID;
  329.     }
  330.     }
  331.     /*
  332.      * If we know our spriteID and we are installing a route to ourselves we
  333.      * can learn (or at least validate our data).
  334.      */
  335.     if ((rpc_SpriteID > 0) && (rpc_SpriteID == spriteID)) {
  336.     char buffer[128];
  337.  
  338.     if (interPtr->netAddress[protocol].type == 0) {
  339.         interPtr->netAddress[protocol] = netAddressPtr[protocol];
  340.         Net_AddrToString(&interPtr->netAddress[protocol], buffer);
  341.         printf("Setting address to %s\n", buffer);
  342.     } else if (Net_AddrCmp(&interPtr->netAddress[protocol], 
  343.             &netAddressPtr[protocol])) {
  344.         Net_AddrToString(&interPtr->netAddress[protocol], buffer);
  345.         printf(
  346.         "Warning: address on interface \"%s\" is currently %s\n",
  347.         interPtr->name,
  348.         buffer);
  349.         Net_AddrToString(&netAddressPtr[protocol], buffer);
  350.         printf("Attempt to install route using address %s ignored.\n",
  351.         buffer);
  352.         status = FAILURE;
  353.     }
  354.     return status;
  355.     }
  356.     routePtr = (Net_Route *) malloc(sizeof(Net_Route));
  357.     MASTER_LOCK(&netRouteMutex);
  358.  
  359.     /*
  360.      * In order to install internet routes our internet address must be set.
  361.      */
  362.     if ((protocol == NET_PROTO_INET) && 
  363.     (!Net_AddrCmp(&interPtr->netAddress[protocol], &netZeroAddress))) {
  364.  
  365.     Boolean     found = FALSE;
  366.     int        addr;
  367.     Net_Route    *tmpPtr;
  368.     /*
  369.      * Try to do a reverse arp to get the internet address.  
  370.      */
  371.     LIST_FORALL(&netRouteArray[NET_BROADCAST_HOSTID], 
  372.         (List_Links *) tmpPtr){
  373.  
  374.         if (tmpPtr->interPtr == interPtr) {
  375.         found = TRUE;
  376.         break;
  377.         }
  378.     }
  379.     if (!found) {
  380.         printf("Can't find broadcast route for interface %s\n",
  381.         interPtr->name);
  382.         MASTER_UNLOCK(&netRouteMutex);
  383.         return FAILURE;
  384.     }
  385.     addr = Net_RevArp(tmpPtr, protocol, (Net_Address *) NIL, 
  386.             &netRouteMutex);
  387.     if (addr == -1) {
  388.         printf("Internet address for interface \"%s\" is not set and\n",
  389.         interPtr->name);
  390.         printf("reverse arp failed.  Can't install route.\n");
  391.         MASTER_UNLOCK(&netRouteMutex);
  392.         return FAILURE;
  393.     }
  394.     interPtr->netAddress[protocol].type = NET_ADDRESS_INET;
  395.     interPtr->netAddress[protocol].address.inet = addr;
  396.     }
  397.     if (spriteID >= NET_NUM_SPRITE_HOSTS) {
  398.     printf("Net route table too small!\n");
  399.     MASTER_UNLOCK(&netRouteMutex);
  400.     return FAILURE;
  401.     } else {
  402.     Net_Route     *tmpPtr;
  403.     if (oldMode) {
  404.         oldRoutePtr = (Net_Route *)NIL;
  405.         LIST_FORALL(&netRouteArray[spriteID], (List_Links *) tmpPtr) {
  406.         if ((tmpPtr->interPtr == interPtr) &&
  407.             (tmpPtr->protocol == protocol)) {
  408.     
  409.             tmpPtr->flags &= ~NET_RFLAGS_VALID;
  410.             oldRoutePtr = tmpPtr;
  411.             break;
  412.         }
  413.         }
  414.     }
  415.     List_InitElement((List_Links *) routePtr);
  416.     List_Insert((List_Links *) routePtr, 
  417.         LIST_ATREAR((List_Links *) &netRouteArray[spriteID]));
  418.     (void) strncpy(netHostInfo[spriteID].name, hostname, 20);
  419.     (void) strncpy(netHostInfo[spriteID].machType, machType, 12);
  420.  
  421.     routePtr->flags = NET_RFLAGS_VALID;
  422.     routePtr->refCount = 0;
  423.     routePtr->spriteID = spriteID;
  424.     routePtr->interPtr = interPtr;
  425.     routePtr->maxPacket = interPtr->maxBytes;
  426.     routePtr->minPacket = interPtr->minBytes;
  427.     routePtr->minRpc = minRpc;
  428.     routePtr->maxRpc = maxRpc;
  429.     routePtr->protocol = protocol;
  430.     routePtr->routeID = (spriteID << 16) | netHostInfo[spriteID].routes++;
  431.     routePtr->userData = clientData;
  432.     (void) sprintf(routePtr->desc, "Route to %s - ", hostname);
  433.     }
  434.     /*
  435.      * Prepare the Route.  This includes the transport header that
  436.      * will be used in messages sent to the Sprite Host.
  437.      */
  438.     headerPtr = (char *) routePtr->buffer;
  439.     switch(interPtr->netType) {
  440.     case NET_NETWORK_ETHER: {
  441.         Net_EtherHdr *etherHdrPtr;
  442.         Net_EtherAddress    etherAddress;
  443.  
  444.         status = Net_GetAddress(&netAddressPtr[NET_PROTO_RAW], 
  445.         (Address) ðerAddress);
  446.         if (status != SUCCESS) {
  447.         panic("Net_InstallRoute: Net_GetAddress failed\n");
  448.         }
  449.         (void) strcat(routePtr->desc, "ethernet, ");
  450.         if (oldMode) {
  451.         /*
  452.          * Fill in an ethernet header for the route.
  453.          * The drivers fill in the source part of the ethernet header 
  454.          * each time they send out a packet.
  455.          */
  456.         if (oldRoutePtr != (Net_Route *) NIL) {
  457.             etherHdrPtr = (Net_EtherHdr *)
  458.                     oldRoutePtr->headerPtr[NET_PROTO_RAW];
  459.             if (Net_EtherAddrCmp(etherAddress,
  460.             NET_ETHER_HDR_DESTINATION(*etherHdrPtr))) {
  461.             char buf[20];
  462.     
  463.             Net_EtherAddrToString(
  464.                 &NET_ETHER_HDR_DESTINATION(*etherHdrPtr), buf);
  465.             printf(
  466.             "Warning: Net_InstallRoute: host <%d> changing ethernet addr\n",
  467.                 spriteID);
  468.             printf("\tOld: %s, ",buf);
  469.             Net_EtherAddrToString(ðerAddress, buf);
  470.             printf("New: %s\n", buf);
  471.             }
  472.         }
  473.         }
  474.         if (protocol == NET_PROTO_RAW) {
  475.         etherHdrPtr = (Net_EtherHdr *)routePtr->buffer;
  476.         NET_ETHER_HDR_TYPE(*etherHdrPtr) = 
  477.             Net_HostToNetShort(NET_ETHER_SPRITE);
  478.         } else {
  479.         /*
  480.          * Make the ethernet header start on an odd 16 bit boundary so
  481.          * that the (internet) header that follows starts on a
  482.          * 32 bit boundary.
  483.          */
  484.         etherHdrPtr = (Net_EtherHdr *)
  485.             ((((int) routePtr->buffer + 5) & ~0x3) - 2);
  486.         NET_ETHER_HDR_TYPE(*etherHdrPtr) = 
  487.                     Net_HostToNetShort(NET_ETHER_IP);
  488.         }
  489.         routePtr->headerPtr[NET_PROTO_RAW] = (Address)etherHdrPtr;
  490.         status = Net_GetAddress(&netAddressPtr[NET_PROTO_RAW],
  491.             (Address) &NET_ETHER_HDR_DESTINATION(*etherHdrPtr));
  492.         if (status != SUCCESS) {
  493.         panic("Net_InstallRoute: Net_GetAddress failed\n");
  494.         }
  495.         status = Net_GetAddress(&interPtr->netAddress[NET_PROTO_RAW],
  496.             (Address) &NET_ETHER_HDR_SOURCE(*etherHdrPtr));
  497.         if (status != SUCCESS) {
  498.         panic("Net_InstallRoute: Net_GetAddress failed\n");
  499.         }
  500.         routePtr->netAddress[NET_PROTO_RAW] = netAddressPtr[NET_PROTO_RAW];
  501.         headerPtr = (char *) etherHdrPtr;
  502.         break;
  503.     }
  504.     case NET_NETWORK_ULTRA: {
  505.         Net_UltraHeader    *ultraHdrPtr;
  506.  
  507.         ultraHdrPtr = (Net_UltraHeader *) routePtr->buffer;
  508.         bzero((char *) ultraHdrPtr, sizeof(Net_UltraHeader));
  509.         (void) strcat(routePtr->desc, "ultranet, ");
  510.         routePtr->headerPtr[NET_PROTO_RAW] = (Address) ultraHdrPtr;
  511.         ultraHdrPtr->remoteAddress = wildcardAddress;
  512.         ultraHdrPtr->remoteAddress.tsapSize=2;
  513.         ultraHdrPtr->remoteAddress.tsap[0]=0xff;
  514.         ultraHdrPtr->remoteAddress.tsap[1]=0xff;
  515.         status = Net_GetAddress(&netAddressPtr[NET_PROTO_RAW], 
  516.         (Address) &ultraHdrPtr->remoteAddress.address);
  517.         if (status != SUCCESS) {
  518.         panic("Net_InstallRoute: Net_GetAddress failed\n");
  519.         }
  520.         ultraHdrPtr->localAddress = wildcardAddress;
  521.         ultraHdrPtr->localAddress.tsapSize=2;
  522.         ultraHdrPtr->localAddress.tsap[0]=0xff;
  523.         ultraHdrPtr->localAddress.tsap[1]=0xff;
  524.         status = Net_GetAddress(&interPtr->netAddress[NET_PROTO_RAW],
  525.         (Address) &ultraHdrPtr->localAddress.address);
  526.         if (status != SUCCESS) {
  527.         panic("Net_InstallRoute: Net_GetAddress failed\n");
  528.         }
  529.         ultraHdrPtr->cmd = NET_ULTRA_DGRAM_SEND_REQ;
  530.         headerPtr = (char *) ultraHdrPtr;
  531.         routePtr->netAddress[NET_PROTO_RAW] = netAddressPtr[NET_PROTO_RAW];
  532.         break;
  533.     }
  534.     case NET_NETWORK_FDDI: {
  535.         Net_FDDIHdr *fddiHdrPtr;
  536.  
  537.         (void) strcat(routePtr->desc, "fddi, ");
  538.         fddiHdrPtr = (Net_FDDIHdr *) routePtr->buffer;
  539.         routePtr->headerPtr[NET_PROTO_RAW] = (Address)fddiHdrPtr;
  540.         bzero((char *) fddiHdrPtr, sizeof(Net_FDDIHdr));
  541.         fddiHdrPtr->frameControl = NET_FDDI_SPRITE;             /***/
  542.         NET_FDDI_ADDR_COPY(netAddressPtr[NET_PROTO_RAW].address.fddi,
  543.                    fddiHdrPtr->dest);
  544.         NET_FDDI_ADDR_COPY(interPtr->netAddress[NET_PROTO_RAW].address.fddi,
  545.                    fddiHdrPtr->source);
  546.         headerPtr = (char *) fddiHdrPtr;
  547.         routePtr->netAddress[NET_PROTO_RAW] = netAddressPtr[NET_PROTO_RAW];
  548.         break;
  549.     }
  550.     default:
  551.         printf("Net_InstallRoute: Unknown interface type %d\n", 
  552.         interPtr->netType);
  553.         return FAILURE;
  554.     }
  555.     headerPtr += net_NetworkHeaderSize[interPtr->netType];
  556.     switch (protocol) {
  557.     case NET_PROTO_RAW:
  558.         (void) strcat(routePtr->desc, "raw");
  559.         break;
  560.     case NET_PROTO_INET: {
  561.         Net_IPHeader *ipHeader;
  562.         (void) strcat(routePtr->desc, "IP");
  563.         ipHeader = (Net_IPHeader *) headerPtr;
  564.         routePtr->headerPtr[protocol] = (Address)ipHeader;
  565.         /*
  566.          * Initialize the template ipHeader.
  567.          */
  568.         bzero((char *)ipHeader, sizeof(Net_IPHeader));
  569.         ipHeader->headerLen = sizeof(Net_IPHeader) / 4;
  570.         ipHeader->version = NET_IP_VERSION;
  571.         ipHeader->typeOfService = 0;
  572.         /*
  573.          * Kernel IP doesn't handle fragmented IP packets (yet).
  574.          */
  575.         ipHeader->flags = NET_IP_DONT_FRAG;
  576.         SWAP_FRAG_OFFSET_HOST_TO_NET(ipHeader);
  577.         ipHeader->timeToLive = NET_IP_MAX_TTL;
  578.         ipHeader->protocol = NET_IP_PROTOCOL_SPRITE;
  579.         status = Net_GetAddress(&interPtr->netAddress[protocol], 
  580.         (Address) &ipHeader->source);
  581.         if (status != SUCCESS) {
  582.         panic("Net_InstallRoute: Net_GetAddress failed\n");
  583.         }
  584.         status = Net_GetAddress(&netAddressPtr[protocol], 
  585.         (Address) &ipHeader->dest);
  586.         if (status != SUCCESS) {
  587.         panic("Net_InstallRoute: Net_GetAddress failed\n");
  588.         }
  589.         /*
  590.          * Precompute the checksum for the ipHeader. This must be
  591.          * corrected when the totalLen field is updated. Note we
  592.          * store the checksum as the 16 bit sum of the packet
  593.          * header to permit easy updating.
  594.          */
  595.         ipHeader->checksum = Net_InetChecksum(sizeof(Net_IPHeader),
  596.                            (Address) ipHeader);
  597.         ipHeader->checksum = ~ipHeader->checksum;
  598.         routePtr->maxPacket -= sizeof(Net_IPHeader);
  599.         routePtr->minPacket -= sizeof(Net_IPHeader);
  600.         if (routePtr->minPacket < 0) {
  601.         routePtr->minPacket = 0;
  602.         }
  603.         routePtr->netAddress[NET_PROTO_INET] = 
  604.         netAddressPtr[NET_PROTO_INET];
  605.         break;
  606.     }
  607.     default: {
  608.         if (oldMode) {
  609.         if (oldRoutePtr != (Net_Route *) NIL) {
  610.             oldRoutePtr->flags |= NET_RFLAGS_VALID;
  611.         }
  612.         }
  613.         printf("Warning: Unsupported route type in Net_InstallRoute\n");
  614.         routePtr->flags &= ~NET_RFLAGS_VALID;
  615.         status = FAILURE;
  616.         break;
  617.     }
  618.     }
  619.     MASTER_UNLOCK(&netRouteMutex);
  620.     if (oldMode) {
  621.     if (oldRoutePtr != (Net_Route *) NIL) {
  622.         Net_DeleteRoute(oldRoutePtr);
  623.     }
  624.     }
  625.     if ((status != SUCCESS) && (routePtr != (Net_Route *) NIL)) {
  626.     Net_DeleteRoute(routePtr);
  627.     }
  628.     return(SUCCESS);
  629. }
  630.  
  631. /*
  632.  *----------------------------------------------------------------------
  633.  *
  634.  * Net_ReleaseRoute --
  635.  *
  636.  *    Releases a route by decrementing its reference count.
  637.  *
  638.  * Results:
  639.  *    None.
  640.  *
  641.  * Side effects:
  642.  *    The route if freed if it is invalid and the reference count is zero.
  643.  *
  644.  *----------------------------------------------------------------------
  645.  */
  646.  
  647. void
  648. Net_ReleaseRoute(routePtr)
  649.     Net_Route     *routePtr;
  650. {
  651.     Boolean     freeIt = FALSE;
  652.     MASTER_LOCK(&netRouteMutex);
  653.     routePtr->refCount--;
  654.     if (Mach_AtInterruptLevel()) {
  655.     goto exit;
  656.     }
  657.     if ((!(routePtr->flags & NET_RFLAGS_VALID)) && 
  658.     (routePtr->refCount <= 0) &&
  659.     (!(routePtr->flags & NET_RFLAGS_DELETING))) {
  660.     routePtr->flags |= NET_RFLAGS_DELETING;
  661.     freeIt = TRUE;
  662.     }
  663. exit:
  664.     MASTER_UNLOCK(&netRouteMutex);
  665.     if (freeIt) {
  666.     List_Remove((List_Links *) routePtr);
  667.     free((char *) routePtr);
  668.     }
  669. }
  670.  
  671. /*
  672.  *----------------------------------------------------------------------
  673.  *
  674.  * Net_DeleteRouteStub --
  675.  *
  676.  *    System call interface for Net_DeleteRoute.
  677.  *
  678.  * Results:
  679.  *    None.
  680.  *
  681.  * Side effects:
  682.  *    None.
  683.  *
  684.  *----------------------------------------------------------------------
  685.  */
  686.  
  687. ReturnStatus
  688. Net_DeleteRouteStub(routeID)
  689.     int        routeID;    /* ID of the route to be deleted. */
  690. {
  691.     int        spriteID;
  692.     Net_Route    *routePtr;
  693.     Boolean    found = FALSE;
  694.  
  695.     spriteID = routeID >> 16;
  696.     if (spriteID < 0 || spriteID >= netNumHosts) {
  697.     return GEN_INVALID_ARG;
  698.     }
  699.     MASTER_LOCK(&netRouteMutex);
  700.     LIST_FORALL(&netRouteArray[spriteID],(List_Links *) routePtr) {
  701.     if (routePtr->routeID == routeID) {
  702.         found = TRUE;
  703.         break;
  704.     }
  705.     }
  706.     MASTER_UNLOCK(&netRouteMutex);
  707.     if (!found) {
  708.     return GEN_INVALID_ARG;
  709.     }
  710.     Net_DeleteRoute(routePtr);
  711.     return SUCCESS;
  712. }
  713.  
  714.  
  715. /*
  716.  *----------------------------------------------------------------------
  717.  *
  718.  * Net_DeleteRoute --
  719.  *
  720.  *    Deletes a route.
  721.  *
  722.  * Results:
  723.  *    A return status.
  724.  *
  725.  * Side effects:
  726.  *    The indicated route is deleted.
  727.  *
  728.  *----------------------------------------------------------------------
  729.  */
  730.  
  731. void
  732. Net_DeleteRoute(routePtr)
  733.     Net_Route    *routePtr;
  734. {
  735.     Boolean     freeIt = FALSE;
  736.     MASTER_LOCK(&netRouteMutex);
  737.     routePtr->flags &= ~NET_RFLAGS_VALID;
  738.     if (Mach_AtInterruptLevel()) {
  739.     goto exit;
  740.     }
  741.     if ((routePtr->refCount <= 0) && 
  742.     (!(routePtr->flags & NET_RFLAGS_DELETING))) {
  743.     routePtr->flags |= NET_RFLAGS_DELETING;
  744.     freeIt = TRUE;
  745.     }
  746. exit:
  747.     MASTER_UNLOCK(&netRouteMutex);
  748.     if (freeIt) {
  749.     List_Remove((List_Links *) routePtr);
  750.     free((char *) routePtr);
  751.     }
  752. }
  753.  
  754. /*
  755.  *----------------------------------------------------------------------
  756.  *
  757.  * Net_IDToRouteOldStub --
  758.  *
  759.  *    Stub for the Test_Stats system call, NET_GET_ROUTE command.
  760.  *    This gets a route and copies it out to user space.
  761.  *    This routine is made obsolete by Net_GetRoutes.
  762.  *
  763.  * Results:
  764.  *    A return status.
  765.  *
  766.  * Side effects:
  767.  *    Copies to user space.
  768.  *
  769.  *----------------------------------------------------------------------
  770.  */
  771. ReturnStatus
  772. Net_IDToRouteOldStub(spriteID, size, argPtr)
  773.     int spriteID;        /* option parameter to Test_Stats */
  774.     int    size;            /* Size of user buffer. */
  775.     Address argPtr;        /* User space buffer to hold route */
  776.  
  777. {
  778. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  779.  
  780.     ReturnStatus status;
  781.     Net_Route *routePtr;
  782.     Net_RouteInfoOld routeInfo;
  783.     int toCopy;
  784.  
  785.     if (spriteID < 0 || spriteID >= netNumHosts) {
  786.     return(SYS_INVALID_ARG);
  787.     }
  788.     routePtr = Net_IDToRoute(spriteID, 0, FALSE, (Sync_Semaphore *) NIL, 0);
  789.     if (routePtr == (Net_Route *)NIL) {
  790.     routeInfo.version = NET_ROUTE_VERSION;
  791.     routeInfo.flags = 0;
  792.     } else {
  793.     FillRouteInfoOld(routePtr, &routeInfo);
  794.     }
  795.     toCopy = MIN(size, sizeof(Net_RouteInfoOld) - sizeof(Net_Header));
  796.     status = Vm_CopyOut(toCopy, (Address)&routeInfo, argPtr);
  797.     if (routePtr == (Net_Route *) NIL) {
  798.     return status;
  799.     }
  800.     if (status == SUCCESS) {
  801.     argPtr += toCopy;
  802.     size -= toCopy;
  803.     toCopy = MIN(size, net_NetworkHeaderSize[routePtr->interPtr->netType]);
  804.     status = Vm_CopyOut(toCopy, 
  805.             (Address)routePtr->headerPtr[NET_PROTO_RAW], 
  806.             argPtr);
  807.     argPtr += toCopy;
  808.     size -= toCopy;
  809.     switch(routePtr->protocol) {
  810.         case NET_PROTO_INET:
  811.         toCopy = MIN(size, sizeof(Net_IPHeader));
  812.         status = Vm_CopyOut(sizeof(Net_IPHeader), 
  813.                  (Address)routePtr->headerPtr[NET_PROTO_INET],
  814.                  argPtr);
  815.         argPtr += toCopy;
  816.         size -= toCopy;
  817.         break;
  818.         default:
  819.         break;
  820.     }
  821.     }
  822.     Net_ReleaseRoute(routePtr);
  823.     return(status);
  824. }
  825.  
  826. /*
  827.  *----------------------------------------------------------------------
  828.  *
  829.  * Net_GetRoutes --
  830.  *
  831.  *    System call to return routes to user-level. If the firstID and
  832.  *    lastID are both -1 then all routes are returned, otherwise
  833.  *    only those routes for hosts with IDs between firstID and
  834.  *    lastID, inclusive, are returned. 
  835.  *
  836.  * Results:
  837.  *    A return status.
  838.  *
  839.  * Side effects:
  840.  *    Copies to user space.
  841.  *
  842.  *----------------------------------------------------------------------
  843.  */
  844. ReturnStatus
  845. Net_GetRoutes(firstID, lastID, infoSize, bufferPtr, buffersUsedPtr)
  846.     int     firstID;        /* ID of first host. */
  847.     int     lastID;            /* ID of last host. */
  848.     int     infoSize;        /* The size of Net_RouteInfo. */
  849.     Address    bufferPtr;        /* Buffer for route info. */
  850.     int        *buffersUsedPtr;    /* Number of buffers used. */
  851. {
  852. #define MIN(a,b) ((a) < (b) ? (a) : (b))
  853.  
  854.     ReturnStatus     status = SUCCESS;
  855.     Net_Route         *routePtr;
  856.     Net_UserRoute    userRoute;
  857.     int            i, j;
  858.     int            size;
  859.     int            count = 0;
  860.  
  861.     if ((firstID < -1) || (firstID >= netNumHosts)) {
  862.     return SYS_INVALID_ARG;
  863.     }
  864.     if ((lastID < -1) || (lastID >= netNumHosts)) {
  865.     return SYS_INVALID_ARG;
  866.     }
  867.     if (lastID < firstID) {
  868.     return SYS_INVALID_ARG;
  869.     }
  870.     if (bufferPtr == USER_NIL) {
  871.     return SYS_ARG_NOACCESS;
  872.     }
  873.     if (firstID == -1) {
  874.     if (lastID != -1) {
  875.         return SYS_INVALID_ARG;
  876.     } else {
  877.         firstID = 0;
  878.         lastID = netNumHosts - 1;
  879.     }
  880.     }
  881.     size = MIN(infoSize, sizeof(Net_UserRoute));
  882.     for (i = firstID; i <= lastID; i++) {
  883.     for (j = 0;; j++) {
  884.         routePtr = Net_IDToRoute(i, j, FALSE, (Sync_Semaphore *) NIL, 0);
  885.         if (routePtr == (Net_Route *) NIL) {
  886.         break;
  887.         }
  888.         FillUserRoute(routePtr, &userRoute);
  889.         Net_ReleaseRoute(routePtr);
  890.         status = Vm_CopyOut(size, (Address)&userRoute, bufferPtr);
  891.         if (status != SUCCESS) {
  892.         goto done;
  893.         }
  894.         bufferPtr += size;
  895.         count++;
  896.     }
  897.     }
  898. done:
  899.     if (buffersUsedPtr != USER_NIL) {
  900.     status = Vm_CopyOut(sizeof(int), (Address) &count, 
  901.         (Address) buffersUsedPtr);
  902.     }
  903.     return(status);
  904. }
  905.  
  906. /*
  907.  *----------------------------------------------------------------------
  908.  *
  909.  * Net_IDToRoute --
  910.  *
  911.  *    Return the route to the host specified by the input sprite id.
  912.  *
  913.  * Results:
  914.  *    A pointer to the route for the host.
  915.  *
  916.  * Side effects:
  917.  *    None.
  918.  *
  919.  *----------------------------------------------------------------------
  920.  */
  921. /*ARGSUSED*/
  922. Net_Route *
  923. Net_IDToRoute(spriteID, index, doArp, mutexPtr, size)
  924.     int     spriteID;    /* Sprite id to find route for. */
  925.     int     index;        /* If >= 0 then the index of the route,
  926.                  * otherwise use the size. */
  927.     Boolean    doArp;        /* Do an arp to find a route? */
  928.     Sync_Semaphore *mutexPtr;    /* Mutex to release when doing arp. */
  929.     int     size;        /* Size of RPC to be sent. */
  930. {
  931.     Net_Route     *routePtr = (Net_Route *) NIL;
  932.     register    Net_Route *tmpPtr;
  933.     int            i;
  934.     ReturnStatus    status;
  935.  
  936.     if (spriteID >= 0 && spriteID < netNumHosts) {
  937.     while (1) {
  938.         i = 0;
  939.         MASTER_LOCK(&netRouteMutex);
  940.         if (index >= 0) {
  941.         LIST_FORALL(&netRouteArray[spriteID],(List_Links *) tmpPtr) {
  942.             if (tmpPtr->flags & NET_RFLAGS_VALID) {
  943.             if (i == index) {
  944.                 routePtr = tmpPtr;
  945.                 break;
  946.             }
  947.             i++;
  948.             }
  949.         }
  950.         } else {
  951.         LIST_FORALL(&netRouteArray[spriteID],(List_Links *) tmpPtr) {
  952.             if ((tmpPtr->minRpc <= size) && (tmpPtr->maxRpc >= size) &&
  953.             (tmpPtr->flags & NET_RFLAGS_VALID)) {
  954.             routePtr = tmpPtr;
  955.             break;
  956.             }
  957.         }
  958.         }
  959.         if (routePtr != (Net_Route *) NIL) {
  960.         routePtr->refCount++;
  961.         }
  962.         MASTER_UNLOCK(&netRouteMutex);
  963.         if (routePtr == (Net_Route *) NIL && doArp) {
  964.         status = Net_Arp(spriteID, mutexPtr);
  965.         if (status != SUCCESS) {
  966.             break;
  967.         }
  968.         doArp = FALSE;
  969.         } else {
  970.         break;
  971.         }
  972.     }
  973.     }
  974.     return(routePtr);
  975. }
  976.  
  977. /*
  978.  *----------------------------------------------------------------------
  979.  *
  980.  * Net_AddrToID --
  981.  *
  982.  *      Determine the Sprite host ID from a network address.  This is
  983.  *      used by a server, or Reverse Arp, to determine a client's Sprite
  984.  *      ID from the client's network address.
  985.  *
  986.  *      This routine scans the route table looking for an address
  987.  *      match with the input address.  
  988.  *
  989.  * Results:
  990.  *      A Sprite hostid for the host at the address.  If the physical
  991.  *      address isn't in the table we return a hostid of -1.
  992.  *
  993.  * Side effects:
  994.  *    None.
  995.  *
  996.  *----------------------------------------------------------------------
  997.  */
  998. int
  999. Net_AddrToID(addressPtr)
  1000.     Net_Address    *addressPtr;        /* Physical address */
  1001. {
  1002.     register Net_Route     *routePtr;
  1003.     register int     i;
  1004.     register int     ID = -1;
  1005.     int            protocol;
  1006.  
  1007.     switch(addressPtr->type) {
  1008.     case NET_ADDRESS_INET: 
  1009.         protocol = NET_PROTO_INET;
  1010.         break;
  1011.     default:
  1012.         protocol = NET_PROTO_RAW;
  1013.         break;
  1014.     }
  1015.  
  1016.     MASTER_LOCK(&netRouteMutex);
  1017.  
  1018.     for (i=0 ; i<netNumHosts ; i++) {
  1019.     LIST_FORALL(&netRouteArray[i],(List_Links *) routePtr) {
  1020.         if ((routePtr->protocol == protocol) &&
  1021.         (Net_AddrCmp(&routePtr->netAddress[protocol], 
  1022.             addressPtr) == 0)) {
  1023.         ID = routePtr->spriteID;
  1024.         break;
  1025.         }
  1026.     }
  1027.     }
  1028.     MASTER_UNLOCK(&netRouteMutex);
  1029.     return(ID);
  1030. }
  1031.  
  1032. /*
  1033.  *----------------------------------------------------------------------
  1034.  *
  1035.  * Net_HdrToAddr --
  1036.  *
  1037.  *    Determine the Sprite host ID from a transport header. 
  1038.  *
  1039.  * Results:
  1040.  *    SUCCESS if the Sprite ID was found ok, FAILURE otherwise.
  1041.  *
  1042.  * Side effects:
  1043.  *    None.
  1044.  *
  1045.  *----------------------------------------------------------------------
  1046.  */
  1047.  
  1048. ReturnStatus
  1049. Net_HdrToAddr(netType, protocol, headerPtr, netAddressPtr) 
  1050.     Net_NetworkType    netType;        /* Type of network. */
  1051.     int            protocol;        /* Network protocol. */
  1052.     Address        headerPtr;        /* The transport header. */
  1053.     Net_Address        *netAddressPtr;        /* The network address. */
  1054. {
  1055.     Address         offsetPtr;
  1056.     ReturnStatus    status = SUCCESS;
  1057.  
  1058.     if (protocol == NET_PROTO_RAW) {
  1059.     switch(netType) {
  1060.         case NET_NETWORK_ETHER: {
  1061.         status = Net_SetAddress(NET_ADDRESS_ETHER, 
  1062.             (Address) 
  1063.             &NET_ETHER_HDR_SOURCE(*((Net_EtherHdr *) headerPtr)),
  1064.             netAddressPtr);
  1065.         break;
  1066.         }
  1067.         case NET_NETWORK_ULTRA: {
  1068.         status = Net_SetAddress(NET_ADDRESS_ULTRA, 
  1069.             (Address) &((Net_UltraHeader *) headerPtr)->remoteAddress,
  1070.             netAddressPtr);
  1071.         break;
  1072.         }
  1073.         case NET_NETWORK_FDDI: {
  1074.             status = Net_SetAddress(NET_ADDRESS_FDDI,
  1075.                 (Address) &((Net_FDDIHdr *) headerPtr)->source,
  1076.                 netAddressPtr);
  1077.             break;
  1078.         }
  1079.         default:
  1080.         printf("Net_HdrToAddr: unknown netType %d\n", netType);
  1081.         return FAILURE;
  1082.     }
  1083.     if (status != SUCCESS) {
  1084.         panic("Net_HdrToAddr: Net_SetAddress failed\n");
  1085.     }
  1086.     } else {
  1087.     offsetPtr = headerPtr + net_NetworkHeaderSize[netType];
  1088.     switch(protocol) {
  1089.         case NET_PROTO_INET : {
  1090.         Net_InetAddress    inetAddress;
  1091.         inetAddress = (Net_InetAddress) 
  1092.             Net_NetToHostInt(((Net_IPHeader *) offsetPtr)->dest);
  1093.         status = Net_SetAddress(NET_ADDRESS_INET, 
  1094.             (Address) &inetAddress, netAddressPtr);
  1095.         break;
  1096.         }
  1097.         default:
  1098.         printf("Net_HdrToAddr: unknown protocol %d\n", protocol);
  1099.         return FAILURE;
  1100.     }
  1101.     if (status != SUCCESS) {
  1102.         panic("Net_HdrToAddr: Net_SetAddress failed\n");
  1103.     }
  1104.     }
  1105.     return SUCCESS;
  1106. }
  1107.  
  1108.  
  1109. /*
  1110.  *----------------------------------------------------------------------
  1111.  *
  1112.  * Net_HdrToID --
  1113.  *
  1114.  *      Determine the Sprite host ID from a transport header.  This is
  1115.  *      used by a server to determine a client's Sprite
  1116.  *      ID from the transport header.
  1117.  *
  1118.  *
  1119.  * Results:
  1120.  *      A Sprite hostid for the host at the address.  If the physical
  1121.  *      address isn't in the table we return a hostid of -1.
  1122.  *
  1123.  * Side effects:
  1124.  *    None.
  1125.  *
  1126.  *----------------------------------------------------------------------
  1127.  */
  1128. int
  1129. Net_HdrToID(netType, protocol, headerPtr)
  1130.     Net_NetworkType    netType;
  1131.     int            protocol;
  1132.     Address headerPtr;    /* Transport header. */
  1133. {
  1134.     Net_Address     netAddress;
  1135.     ReturnStatus    status;
  1136.  
  1137.     status = Net_HdrToAddr(netType, protocol, headerPtr, &netAddress);
  1138.     if (status != SUCCESS) {
  1139.     printf("Net_HdrToID: unable to get address from header\n");
  1140.     return -1;
  1141.     }
  1142.     return Net_AddrToID(&netAddress);
  1143. }
  1144.  
  1145.  
  1146. /*
  1147.  *----------------------------------------------------------------------
  1148.  *
  1149.  * Net_HdrDestString --
  1150.  *
  1151.  *    Build a printable message of the destination address from a 
  1152.  *    transport header.
  1153.  *
  1154.  *
  1155.  * Results:
  1156.  *    None.
  1157.  *
  1158.  * Side effects:
  1159.  *    None.
  1160.  *
  1161.  *----------------------------------------------------------------------
  1162.  */
  1163. void
  1164. Net_HdrDestString(netType, protocol, headerPtr, bufferLen, buffer)
  1165.     Net_NetworkType    netType;
  1166.     int            protocol;
  1167.     Address headerPtr;    /* Transport header. */
  1168.     int    bufferLen;    /* Length of buffer. */
  1169.     char *buffer;    /* Destination memory for destination string. */
  1170.  
  1171. {
  1172.     Net_Address     netAddress;
  1173.     static char        tmpBuffer[128];
  1174.     ReturnStatus    status;
  1175.  
  1176.     *buffer = '\0';
  1177.     status = Net_HdrToAddr(netType, protocol, headerPtr, &netAddress);
  1178.     if (status != SUCCESS) {
  1179.     printf("Net_HdrDestString: unable to get address from header\n");
  1180.     return;
  1181.     }
  1182.     Net_AddrToString(&netAddress, tmpBuffer);
  1183.     (void) strncpy(buffer, tmpBuffer, bufferLen-1);
  1184.     return;
  1185. }
  1186.  
  1187.  
  1188. /*
  1189.  *----------------------------------------------------------------------------
  1190.  *
  1191.  * Net_SpriteIDToName --
  1192.  *
  1193.  *    Map from a Sprite ID to a host name.
  1194.  *
  1195.  * Results:
  1196.  *      None.
  1197.  *
  1198.  * Side effects:
  1199.  *      None.
  1200.  *
  1201.  *----------------------------------------------------------------------------
  1202.  */
  1203.  
  1204. void
  1205. Net_SpriteIDToName(spriteID, bufferLen, buffer)
  1206.     int     spriteID;
  1207.     int        bufferLen;
  1208.     char     *buffer;
  1209. {
  1210.     *buffer = '\0';
  1211.     MASTER_LOCK(&netRouteMutex);
  1212.     if (spriteID >= 0 && spriteID < netNumHosts) {
  1213.     (void) strncpy(buffer, netHostInfo[spriteID].name, bufferLen-1);
  1214.     }
  1215.     MASTER_UNLOCK(&netRouteMutex);
  1216.     return;
  1217. }
  1218.  
  1219. /*
  1220.  *----------------------------------------------------------------------------
  1221.  *
  1222.  * Net_SpriteIDToMachType --
  1223.  *
  1224.  *    Map from a Sprite ID to a machine type string.  This string is
  1225.  *    used by the filesystem when expanding $MACHINE in pathnames.
  1226.  *
  1227.  * Results:
  1228.  *      A pointer to a string identifying the machine type, i.e. "sun3".
  1229.  *
  1230.  * Side effects:
  1231.  *      None.
  1232.  *
  1233.  *----------------------------------------------------------------------------
  1234.  */
  1235.  
  1236. void
  1237. Net_SpriteIDToMachType(spriteID, bufferLen, buffer)
  1238.     int     spriteID;
  1239.     int        bufferLen;
  1240.     char    *buffer;
  1241. {
  1242.     *buffer = '\0';
  1243.     MASTER_LOCK(&netRouteMutex);
  1244.     if (spriteID >= 0 && spriteID < netNumHosts) {
  1245.     (void) strncpy(buffer, netHostInfo[spriteID].machType, bufferLen-1);
  1246.     }
  1247.     MASTER_UNLOCK(&netRouteMutex);
  1248.     return;
  1249. }
  1250.  
  1251. /*
  1252.  *----------------------------------------------------------------------
  1253.  *
  1254.  * Net_HostPrint --
  1255.  *
  1256.  *    Print out a statement concerning a host.  This maps to a
  1257.  *    string hostname if possible, and prints out the message.
  1258.  *
  1259.  * Results:
  1260.  *    None.
  1261.  *
  1262.  * Side effects:
  1263.  *    printf.
  1264.  *
  1265.  *----------------------------------------------------------------------
  1266.  */
  1267.  
  1268. void
  1269. Net_HostPrint(spriteID, string)
  1270.     int spriteID;
  1271.     char *string;
  1272. {
  1273.     Sys_HostPrint(spriteID, string);
  1274.     return;
  1275. }
  1276.  
  1277. /*
  1278.  *----------------------------------------------------------------------
  1279.  *
  1280.  * FillUserRoute --
  1281.  *
  1282.  *    Converts from a Net_Route to a Net_UserRoute. Net_UserRoute
  1283.  *     is the structure that is passed to user-level.
  1284.  *
  1285.  * Results:
  1286.  *    None.
  1287.  *
  1288.  * Side effects:
  1289.  *    None.
  1290.  *
  1291.  *----------------------------------------------------------------------
  1292.  */
  1293.  
  1294. static void
  1295. FillUserRoute(routePtr, userRoutePtr)
  1296.     Net_Route        *routePtr;     /* The route structure. */
  1297.     Net_UserRoute    *userRoutePtr;    /* The user version of the route. */
  1298. {
  1299.     int        i;
  1300.  
  1301.     userRoutePtr->version = NET_ROUTE_VERSION;
  1302.     userRoutePtr->spriteID = routePtr->spriteID;
  1303.     userRoutePtr->protocol = routePtr->protocol;
  1304.     userRoutePtr->interAddress = routePtr->interPtr->netAddress[NET_PROTO_RAW];
  1305.     userRoutePtr->netType = routePtr->interPtr->netType;
  1306.     userRoutePtr->refCount = routePtr->refCount;
  1307.     userRoutePtr->routeID = routePtr->routeID;
  1308.     userRoutePtr->flags = routePtr->flags;
  1309.     userRoutePtr->maxPacket = routePtr->maxPacket;
  1310.     userRoutePtr->minPacket = routePtr->minPacket;
  1311.     userRoutePtr->maxRpc = routePtr->maxRpc;
  1312.     userRoutePtr->minRpc = routePtr->minRpc;
  1313.     userRoutePtr->userData = routePtr->userData;
  1314.     for(i = 0; i < NET_MAX_PROTOCOLS; i++) {
  1315.     userRoutePtr->netAddress[i] = routePtr->netAddress[i];
  1316.     }
  1317.     (void) strncpy(userRoutePtr->hostname, 
  1318.             netHostInfo[routePtr->spriteID].name, 20);
  1319.     (void) strncpy(userRoutePtr->machType,
  1320.                netHostInfo[routePtr->spriteID].machType, 12);
  1321.     (void) strncpy(userRoutePtr->desc, routePtr->desc, 64);
  1322. }
  1323.  
  1324. /*
  1325.  *----------------------------------------------------------------------
  1326.  *
  1327.  * FillRouteInfoOld --
  1328.  *
  1329.  *    Converts from a Net_Route to a Net_RouteInfoOld. Net_RouteInfoOld
  1330.  *     is the structure that is passed to user-level.
  1331.  *    This routine is here for backwards compatibility and can
  1332.  *    be removed as soon as Net_IDToRouteStub is gone.
  1333.  *
  1334.  * Results:
  1335.  *    None.
  1336.  *
  1337.  * Side effects:
  1338.  *    None.
  1339.  *
  1340.  *----------------------------------------------------------------------
  1341.  */
  1342.  
  1343. static void
  1344. FillRouteInfoOld(routePtr, infoPtr)
  1345.     Net_Route        *routePtr;     /* The route structure. */
  1346.     Net_RouteInfoOld    *infoPtr;    /* The route info structure. */
  1347. {
  1348.     int            i;
  1349.     ReturnStatus    status;
  1350.  
  1351.     infoPtr->version = NET_ROUTE_VERSION;
  1352.     infoPtr->spriteID = routePtr->spriteID;
  1353.     infoPtr->protocol = routePtr->protocol;
  1354.     infoPtr->interface = routePtr->interPtr->number;
  1355.     infoPtr->netType = routePtr->interPtr->netType;
  1356.     infoPtr->refCount = routePtr->refCount;
  1357.     infoPtr->routeID = routePtr->routeID;
  1358.     infoPtr->flags = routePtr->flags;
  1359.     infoPtr->maxBytes = routePtr->maxPacket;
  1360.     infoPtr->minBytes = routePtr->minPacket;
  1361.     infoPtr->userData = routePtr->userData;
  1362.     for(i = 0; i < NET_MAX_PROTOCOLS; i++) {
  1363.     status = Net_GetAddress(&routePtr->netAddress[i], 
  1364.         (Address) &infoPtr->netAddress[i]);
  1365.     if (status != SUCCESS) {
  1366.         break;
  1367.     }
  1368.     }
  1369.     (void) strncpy(infoPtr->hostname, netHostInfo[routePtr->spriteID].name, 20);
  1370.     (void) strncpy(infoPtr->machType,
  1371.                netHostInfo[routePtr->spriteID].machType, 12);
  1372.     (void) strncpy(infoPtr->desc, routePtr->desc, 64);
  1373. }
  1374.  
  1375.